home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / unixSyscall / RCS / socket.c,v < prev    next >
Text File  |  1992-03-27  |  39KB  |  1,636 lines
  1. head     1.16;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.16
  10. date     92.03.27.12.26.24;  author shirriff;  state Exp;
  11. branches ;
  12. next     1.15;
  13.  
  14. 1.15
  15. date     91.09.09.15.00.37;  author dlong;  state Exp;
  16. branches ;
  17. next     1.14;
  18.  
  19. 1.14
  20. date     91.09.06.18.41.01;  author dlong;  state Exp;
  21. branches ;
  22. next     1.13;
  23.  
  24. 1.13
  25. date     91.08.12.17.06.47;  author mottsmth;  state Exp;
  26. branches ;
  27. next     1.12;
  28.  
  29. 1.12
  30. date     91.07.17.16.04.46;  author mendel;  state Exp;
  31. branches ;
  32. next     1.11;
  33.  
  34. 1.11
  35. date     89.09.12.11.43.48;  author nelson;  state Exp;
  36. branches ;
  37. next     1.10;
  38.  
  39. 1.10
  40. date     88.10.24.09.15.51;  author douglis;  state Exp;
  41. branches ;
  42. next     1.9;
  43.  
  44. 1.9
  45. date     88.07.29.17.39.36;  author ouster;  state Exp;
  46. branches ;
  47. next     1.8;
  48.  
  49. 1.8
  50. date     88.07.25.14.53.31;  author ouster;  state Exp;
  51. branches ;
  52. next     1.7;
  53.  
  54. 1.7
  55. date     88.07.25.14.23.42;  author ouster;  state Exp;
  56. branches ;
  57. next     1.6;
  58.  
  59. 1.6
  60. date     88.07.25.11.25.10;  author ouster;  state Exp;
  61. branches ;
  62. next     1.5;
  63.  
  64. 1.5
  65. date     88.07.25.10.39.54;  author ouster;  state Exp;
  66. branches ;
  67. next     1.4;
  68.  
  69. 1.4
  70. date     88.06.21.17.25.03;  author ouster;  state Exp;
  71. branches ;
  72. next     1.3;
  73.  
  74. 1.3
  75. date     88.06.21.11.47.43;  author ouster;  state Exp;
  76. branches ;
  77. next     1.2;
  78.  
  79. 1.2
  80. date     88.06.21.11.22.46;  author ouster;  state Exp;
  81. branches ;
  82. next     1.1;
  83.  
  84. 1.1
  85. date     88.06.19.14.32.03;  author ouster;  state Exp;
  86. branches ;
  87. next     ;
  88.  
  89.  
  90. desc
  91. @@
  92.  
  93.  
  94. 1.16
  95. log
  96. @Dlong's patch so socket will retry if interrupted by signal.
  97. @
  98. text
  99. @/* 
  100.  * socket.c --
  101.  *
  102.  *    Routines to emulate 4.3 BSD socket-related system calls for IPC
  103.  *    using the Internet protocol suite. The routines make calls to 
  104.  *    the Sprite Internet Server using Sprite system calls.
  105.  *
  106.  * Copyright 1987 Regents of the University of California
  107.  * All rights reserved.
  108.  */
  109.  
  110. #ifndef lint
  111. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/socket.c,v 1.15 91/09/09 15:00:37 dlong Exp Locker: shirriff $ SPRITE (Berkeley)";
  112. #endif not lint
  113.  
  114. #include <sprite.h>
  115. #include <bit.h>
  116. #include <dev/net.h>
  117. #include <fs.h>
  118. #include <inet.h>
  119. #include <status.h>
  120. #include <stdio.h>
  121. #include <stdlib.h>
  122. #include <sys.h>
  123. #include <sys/types.h>
  124. #include <sys/socket.h>
  125. #include <sys/uio.h>
  126. #include <netinet/in.h>
  127. #include <errno.h>
  128.  
  129. #include "compatInt.h"
  130.  
  131. static ReturnStatus Wait();
  132.  
  133. #ifdef DEBUG
  134. #  define    DebugMsg(status, string)     Stat_PrintMsg(status, string)
  135. #else
  136. #  define    DebugMsg(status, string)    ;
  137. #endif
  138.  
  139. static Boolean    gotHostName = FALSE;
  140. static char     myHostName[100];
  141. static char     streamDevice[100];
  142. static char     dgramDevice[100];
  143. static char     rawDevice[100];
  144.  
  145.  
  146. /*
  147.  *----------------------------------------------------------------------
  148.  *
  149.  * accept --
  150.  *
  151.  *    Accept a stream connection request. This call will create a new
  152.  *    connection to the Inet server upon notification that a remote
  153.  *    connection request is pending.
  154.  *
  155.  *    If the socket is non-blocking and no remote connection requests are
  156.  *    pending, EWOULDBLOCK is returned. If the socket is blockable,
  157.  *    this routine will wait until a remote connection request arrives.
  158.  *
  159.  * Results:
  160.  *    If > 0, the stream ID of the new connection.
  161.  *    If UNIX_ERROR, errno = 
  162.  *    EINVAL        - Bad size for *namePtr.
  163.  *    EWOULDBLOCK    - Non pending requests.
  164.  *
  165.  * Side effects:
  166.  *    A new stream is created.
  167.  *
  168.  *----------------------------------------------------------------------
  169.  */
  170.  
  171. int
  172. accept(socketID, addrPtr, addrLenPtr)
  173.     int            socketID;    /* Socket to listen on. */
  174.     struct sockaddr_in    *addrPtr;    /* Address of newly-accepted 
  175.                      * connection. (out) */
  176.     int            *addrLenPtr;    /* Size of *addrPtr. (in/out) */
  177. {
  178.     ReturnStatus    status;
  179.     int            newSocket;
  180.     ClientData        acceptToken;
  181.     int            addrLen;
  182.  
  183.     if (addrLenPtr == (int *) NULL) {
  184.     addrLen = 0;
  185.     addrPtr = (struct sockaddr_in *) NULL;
  186.     } else {
  187.     /*
  188.      * We deal with just Internet sockets.
  189.      */
  190.  
  191.     addrLen = *addrLenPtr;
  192.     if (addrLen < sizeof(struct sockaddr_in)) {
  193.         errno = EINVAL;
  194.         return(UNIX_ERROR);
  195.     }
  196.     }
  197.  
  198.  
  199.     /*
  200.      * Tell the Inet server to accept connections on the socket.  If a
  201.      * connection is made, a token is returned that is used to convert the
  202.      * connection into a new socket.  If no connections are currently
  203.      * available and the socket is non-blocking, FS_WOULD_BLOCK is
  204.      * returned. If the socket is blockable, the ioctl returns
  205.      * NET_NO_CONNECTS so and Wait() must be used to wait for a
  206.      * connection.
  207.      */
  208.  
  209.     status = Fs_IOControl(socketID, IOC_NET_ACCEPT_CONN_1, 
  210.             0, (Address) NULL, 
  211.             sizeof(acceptToken), (Address) &acceptToken);
  212.  
  213.     switch (status) {
  214.     case SUCCESS:
  215.         break;
  216.  
  217.     case FS_WOULD_BLOCK:
  218.         errno = EWOULDBLOCK;
  219.         return(UNIX_ERROR);
  220.         break;
  221.  
  222.         case NET_NO_CONNECTS:
  223.         /*
  224.          * Wait for the server to tell us that a request has arrived.
  225.          */
  226.         (void) Wait(socketID, TRUE, (Time *) NULL);
  227.  
  228.         /*
  229.          * There's a pending connection so retry the ioctl.
  230.          */
  231.         status = Fs_IOControl(socketID, IOC_NET_ACCEPT_CONN_1, 
  232.                 0, (Address) NULL, 
  233.                 sizeof(acceptToken), (Address) &acceptToken);
  234.         if (status != SUCCESS) {
  235.         DebugMsg(status, "accept (ioctl 1b)");
  236.         errno = Compat_MapCode(status);
  237.         return(UNIX_ERROR);
  238.         }
  239.         break;
  240.  
  241.     default:
  242.         DebugMsg(status, "accept (ioctl 1a)");
  243.         errno = Compat_MapCode(status);
  244.         return(UNIX_ERROR);
  245.         break;
  246.     } 
  247.  
  248.  
  249.     /*
  250.      * Create the new socket. This socket will be converted into the new
  251.      * connection.
  252.      */
  253.  
  254.     status = Fs_Open(streamDevice, FS_READ|FS_WRITE, 0666, &newSocket);
  255.     if (status != SUCCESS) {
  256.  
  257.     DebugMsg(status, "accept (open)");
  258.     errno = Compat_MapCode(status);
  259.     return(UNIX_ERROR);
  260.     }
  261.  
  262.     /*
  263.      * Make the new socket have the same characteristics as the
  264.      * connection socket. Also, find out who we are connected to.
  265.      */
  266.     status = Fs_IOControl(newSocket, IOC_NET_ACCEPT_CONN_2, 
  267.             sizeof(acceptToken), (Address) &acceptToken, 
  268.             addrLen, (Address) addrPtr);
  269.  
  270.     if (status != SUCCESS) {
  271.     DebugMsg(status, "accept (ioctl 2)");
  272.     errno = Compat_MapCode(status);
  273.     return(UNIX_ERROR);
  274.     }
  275.     if (addrLen > 0) {
  276.     addrPtr->sin_family = AF_INET;
  277.     }
  278.  
  279.     return(newSocket);
  280. }
  281.  
  282. /*
  283.  *----------------------------------------------------------------------
  284.  *
  285.  * bind --
  286.  *
  287.  *    Assigns a local <address,port> tuple to a socket that does 
  288.  *    not have one.
  289.  *
  290.  * Results:
  291.  *    If 0        - Successful.
  292.  *    If UNIX_ERROR, then errno = 
  293.  *    EINVAL        - Bad size for *namePtr, already bound to an address.
  294.  *    EADDRINUSE    - The address is already in use.
  295.  *    EADDRNOTAVAIL    - The address is not valid for this host.
  296.  *
  297.  * Side effects:
  298.  *    The socket local address is set.
  299.  *
  300.  *----------------------------------------------------------------------
  301.  */
  302.  
  303. int
  304. bind(socketID, namePtr, nameLen)
  305.     int            socketID;    /* Stream ID of unnamed socket. */
  306.     struct sockaddr    *namePtr;    /* Local address,port for this socket.*/
  307.     int            nameLen;    /* Size of *namePtr. */
  308. {
  309.     ReturnStatus    status;
  310.  
  311.     if (nameLen != sizeof(struct sockaddr_in)) {
  312.     errno = EINVAL;
  313.     return(UNIX_ERROR);
  314.     }
  315.  
  316.     status = Fs_IOControl(socketID, IOC_NET_SET_LOCAL_ADDR, 
  317.             nameLen, (Address) namePtr, 
  318.             0, (Address) NULL);
  319.  
  320.     if (status != SUCCESS) {
  321.     DebugMsg(status, "bind");
  322.     errno = Compat_MapCode(status);
  323.     return(UNIX_ERROR);
  324.     }
  325.     return(UNIX_SUCCESS);
  326. }
  327.  
  328. /*
  329.  *----------------------------------------------------------------------
  330.  *
  331.  * connect --
  332.  *
  333.  *    For a stream socket, create a connection to a remote host.
  334.  *    For a datagram socket, only receive datagrams from this remote 
  335.  *    address.
  336.  *
  337.  * Results:
  338.  *    If 0        - Successful.
  339.  *    If UNIX_ERROR, then errno = 
  340.  *    EINVAL        - Bad size for *namePtr,
  341.  *    EADDRINUSE    - The address is already in use.
  342.  *    EADDRNOTAVAIL    - The address is not valid for this host.
  343.  *    EISCONN        - The socket is already connected.
  344.  *    ETIMEDOUT    - The connection request timed-out.
  345.  *    ECONNREFUSED    - The remote host refused the connection.
  346.  *    ENETUNREACH    - The network isn't reachable from this host.
  347.  *    EWOULDBLOCK    - If non-blocking, the connection can't be completed
  348.  *                immediately.
  349.  *    EFAULT        - Invalid argument to the ioctl.
  350.  *
  351.  * Side effects:
  352.  *    A local address for the socket is given if it did not have one 
  353.  *    already.
  354.  *
  355.  *----------------------------------------------------------------------
  356.  */
  357.  
  358. int
  359. connect(socketID, namePtr, nameLen)
  360.     int            socketID;    /* Stream ID of socket. */
  361.     struct sockaddr    *namePtr;    /* Remote address,port to connect to.*/
  362.     int            nameLen;    /* Size of *namePtr. */
  363. {
  364.     ReturnStatus    status;
  365.     Time        oneMin;
  366.  
  367.     if (nameLen != sizeof(struct sockaddr_in)) {
  368.     errno = EINVAL;
  369.     return(UNIX_ERROR);
  370.     }
  371.  
  372.     status = Fs_IOControl(socketID, IOC_NET_CONNECT,
  373.             nameLen, (Address) namePtr, 
  374.             0, (Address) NULL);
  375.  
  376.     if (status == FS_WOULD_BLOCK) {
  377.     int flags = 0;
  378.     int statLen = sizeof(status);
  379.  
  380.     /*
  381.      * The connection didn't immeadiately complete, so wait if
  382.      * we're blocking or return EWOULDBLOCK if we're non-blocking.
  383.      */
  384.     status = Fs_IOControl(socketID, IOC_GET_FLAGS, 
  385.             0, (Address) NULL,
  386.             sizeof(flags), (Address) &flags);
  387.  
  388.     if (status != SUCCESS) {
  389.         DebugMsg(status, "connect (ioctl)");
  390.         panic("connect: GET_FLAGS failed.\n");
  391.     }
  392.  
  393.     if (flags & IOC_NON_BLOCKING) {
  394.         errno = EWOULDBLOCK;
  395.         return(UNIX_ERROR);
  396.     } 
  397.  
  398.     oneMin = time_OneMinute;
  399.     status = Wait(socketID, FALSE, &oneMin);
  400.  
  401.     if (status == FS_TIMEOUT) {
  402.         DebugMsg(status, "connect (select)");
  403.         errno = ETIMEDOUT;
  404.         return(UNIX_ERROR);
  405.     }
  406.  
  407.     /*
  408.      * See if the connection successfully completed. getsockopt converts
  409.      * the status to its Unix equivalent.
  410.      */
  411.     if (getsockopt(socketID, SOL_SOCKET, SO_ERROR, (char *) &status,
  412.         &statLen) < 0) {
  413.         return(UNIX_ERROR);
  414.     }
  415.     if (status != UNIX_SUCCESS) {
  416.         errno = status;
  417.         return(UNIX_ERROR);
  418.     }
  419.     return(UNIX_SUCCESS);
  420.  
  421.     } else if (status != SUCCESS) {
  422.     DebugMsg(status, "connect");
  423.     errno = Compat_MapCode(status);
  424.     return(UNIX_ERROR);
  425.     }
  426.     return(UNIX_SUCCESS);
  427. }
  428.  
  429. /*
  430.  *----------------------------------------------------------------------
  431.  *
  432.  * getpeername --
  433.  *
  434.  *    Find out the remote address that this socket is connected to.
  435.  *
  436.  * Results:
  437.  *    If 0        - Successful.
  438.  *    If UNIX_ERROR, then errno = 
  439.  *    EINVAL        - Bad size for *namePtr.
  440.  *    ENOTCONN    - The socket is not connected.
  441.  *    EFAULT        - Invalid argument to the ioctl.
  442.  *
  443.  * Side effects:
  444.  *    None.
  445.  *
  446.  *----------------------------------------------------------------------
  447.  */
  448.  
  449. int
  450. getpeername(socketID, namePtr, nameLenPtr)
  451.     int            socketID;    /* Stream ID of socket connected to 
  452.                      * remote peer. */
  453.     struct sockaddr    *namePtr;    /* Upon return, <addr,port> for 
  454.                          * remote peer. */
  455.     int            *nameLenPtr;    /* Size of *namePtr. (in/out) */
  456. {
  457.     ReturnStatus    status;
  458.  
  459.     /*
  460.      * Make sure the struct is at least as big as an internet address.
  461.      * It can be bigger because of unions with dec net structures.
  462.      */
  463.     if (nameLenPtr == (int *) NULL ||
  464.     *nameLenPtr < sizeof(struct sockaddr_in)) {
  465.     errno = EINVAL;
  466.     return(UNIX_ERROR);
  467.     }
  468.     *nameLenPtr = sizeof(struct sockaddr_in);
  469.  
  470.     status = Fs_IOControl(socketID, IOC_NET_GET_REMOTE_ADDR, 
  471.             0, (Address) NULL, 
  472.             *nameLenPtr, (Address) namePtr);
  473.  
  474.     if (status != SUCCESS) {
  475.     DebugMsg(status, "getpeername");
  476.     errno = Compat_MapCode(status);
  477.     return(UNIX_ERROR);
  478.     }
  479.     return(UNIX_SUCCESS);
  480. }
  481.  
  482. /*
  483.  *----------------------------------------------------------------------
  484.  *
  485.  * getsockname --
  486.  *
  487.  *    Find out the local address for this socket, which was
  488.  *    set with the bind routine or by the connect routine.
  489.  *
  490.  * Results:
  491.  *    If 0        - Successful.
  492.  *    If UNIX_ERROR, then errno = 
  493.  *    EINVAL        - Bad size for *namePtr.
  494.  *    EFAULT        - Invalid argument to the ioctl.
  495.  *
  496.  * Side effects:
  497.  *    None.
  498.  *
  499.  *----------------------------------------------------------------------
  500.  */
  501.  
  502. int
  503. getsockname(socketID, namePtr, nameLenPtr)
  504.     int            socketID;    /* Stream ID of socket to get name of.*/
  505.     struct sockaddr    *namePtr;    /* Upon return, current <addr,port> for
  506.                      * this socket. */
  507.     int            *nameLenPtr;    /* Size of *namePtr. (in/out) */
  508. {
  509.     ReturnStatus    status;
  510.  
  511.     if (nameLenPtr == (int *) NULL ||
  512.     *nameLenPtr != sizeof(struct sockaddr_in)) {
  513.     errno = EINVAL;
  514.     return(UNIX_ERROR);
  515.     }
  516.  
  517.     status = Fs_IOControl(socketID, IOC_NET_GET_LOCAL_ADDR, 
  518.             0, (Address) NULL, 
  519.             *nameLenPtr, (Address) namePtr);
  520.  
  521.     if (status != SUCCESS) {
  522.     DebugMsg(status, "getsockname");
  523.     errno = Compat_MapCode(status);
  524.     return(UNIX_ERROR);
  525.     }
  526.     return(UNIX_SUCCESS);
  527. }
  528.  
  529. /*
  530.  *----------------------------------------------------------------------
  531.  *
  532.  * getsockopt --
  533.  *
  534.  *    Get the value for a socket option.
  535.  *
  536.  * Results:
  537.  *    If 0        - Successful.
  538.  *    If UNIX_ERROR, then errno = 
  539.  *    EFAULT        - Invalid argument to the ioctl.
  540.  *
  541.  * Side effects:
  542.  *    None.
  543.  *
  544.  *----------------------------------------------------------------------
  545.  */
  546.  
  547. int
  548. getsockopt(socketID, level, optName, optVal, optLenPtr)
  549.     int        socketID;    /* Stream ID of socket to get options on. */
  550.     int        level;        /* Socket or protocol level to get the option.*/
  551.     int        optName;    /* Type of option to get. */
  552.     char    *optVal;    /* Address of buffer to store the result. */
  553.     int        *optLenPtr;    /* In: Size of *optVal, out: # of bytes stored
  554.                  * in *optVal. */
  555. {
  556.     ReturnStatus    status;
  557.     int            optionsArray[2];
  558.  
  559.     /*
  560.      * OptionsArray is used to give the server the values of "level"
  561.      * and "optName". A buffer ("newBufPtr") is needed to get the option
  562.      * value and the length of the value.
  563.      */
  564.     optionsArray[0] = level;
  565.     optionsArray[1] = optName;
  566.  
  567.     status = Fs_IOControl(socketID, IOC_NET_GET_OPTION,
  568.             sizeof(optionsArray), (Address) optionsArray, 
  569.             *optLenPtr, (Address) optVal);
  570.  
  571.     if (status != SUCCESS) {
  572.     DebugMsg(status, "getsockopt");
  573.     errno = Compat_MapCode(status);
  574.     return(UNIX_ERROR);
  575.     }
  576.  
  577.     if (optName == SO_ERROR) {
  578.     /*
  579.      * The error value is a Sprite ReturnStatus so we must convert it
  580.      * to the equivalent Unix value.
  581.      */
  582.  
  583.     *(int *)optVal = Compat_MapCode(*(int *)optVal);
  584.     }
  585.  
  586.     return(UNIX_SUCCESS);
  587. }
  588.  
  589. /*
  590.  *----------------------------------------------------------------------
  591.  *
  592.  * setsockopt --
  593.  *
  594.  *    Set the value for a socket option.
  595.  *
  596.  * Results:
  597.  *    If 0        - Successful.
  598.  *    If UNIX_ERROR, then errno = 
  599.  *    EFAULT        - Invalid argument to the ioctl.
  600.  *
  601.  * Side effects:
  602.  *    None.
  603.  *
  604.  *----------------------------------------------------------------------
  605.  */
  606.  
  607. /*VARARGS  (makes lint happy) */
  608. int
  609. setsockopt(socketID, level, optName, optVal, optLen)
  610.     int        socketID;    /* Stream ID of socket to set options on. */
  611.     int        level;        /* Socket or protocol level to get the option.*/
  612.     int        optName;    /* Type of option to get. */
  613.     char    *optVal;    /* Address of buffer to store the result. */
  614.     int        optLen;        /* Size of *optVal. */
  615. {
  616.     ReturnStatus    status;
  617.     int            *newBufPtr;
  618.  
  619.     /*
  620.      * To pass the level, the type of option and the option value to the
  621.      * server, we allocate a new buffer and put the level and type in the
  622.      * first 2 slots and then copy the value to the rest of the buffer.
  623.      */
  624.     newBufPtr = (int *) malloc((unsigned) (2 * sizeof(int) + optLen));
  625.     newBufPtr[0] = level;
  626.     newBufPtr[1] = optName;
  627.     bcopy(optVal, (char *) &newBufPtr[2], optLen);
  628.  
  629.     status = Fs_IOControl(socketID, IOC_NET_SET_OPTION,
  630.             2 * sizeof(int) + optLen, (Address) newBufPtr,
  631.             0, (Address) NULL);
  632.  
  633.     free((char *) newBufPtr);
  634.  
  635.     if (status != SUCCESS) {
  636.     DebugMsg(status, "getsockopt");
  637.     errno = Compat_MapCode(status);
  638.     return(UNIX_ERROR);
  639.     }
  640.     return(UNIX_SUCCESS);
  641. }
  642.  
  643. /*
  644.  *----------------------------------------------------------------------
  645.  *
  646.  * listen --
  647.  *
  648.  *    Allows a stream socket to accept remote connection requests and to
  649.  *    specify how many such requests will be queued up before they 
  650.  *    are refused.
  651.  *
  652.  * Results:
  653.  *    If 0        - Successful.
  654.  *    If UNIX_ERROR, then errno = 
  655.  *    EOPNOTSUPP    - The socket type doesn't allow a listen operation.
  656.  *    EFAULT        - Invalid argument to the ioctl.
  657.  *
  658.  * Side effects:
  659.  *    None.
  660.  *
  661.  *----------------------------------------------------------------------
  662.  */
  663.  
  664. int
  665. listen(socketID, backlog)
  666.     int    socketID;    /* Stream ID of socket to be put in listen mode. */
  667.     int    backlog;    /* How many connection requests to queue. */
  668. {
  669.     ReturnStatus    status;
  670.  
  671.     status = Fs_IOControl(socketID, IOC_NET_LISTEN,
  672.             sizeof(backlog), (Address) &backlog, 
  673.             0, (Address) NULL);
  674.  
  675.     if (status != SUCCESS) {
  676.     DebugMsg(status, "listen");
  677.     errno = Compat_MapCode(status);
  678.     return(UNIX_ERROR);
  679.     }
  680.     return(UNIX_SUCCESS);
  681. }
  682.  
  683. /*
  684.  *----------------------------------------------------------------------
  685.  *
  686.  * recv --
  687.  *
  688.  *    Read data from a connected socket. 
  689.  *
  690.  * Results:
  691.  *    See recvfrom().
  692.  *
  693.  * Side effects:
  694.  *    None.
  695.  *
  696.  *----------------------------------------------------------------------
  697.  */
  698.  
  699. int
  700. recv(socketID, bufPtr, bufSize, flags)
  701.     int        socketID;
  702.     char    *bufPtr;    /* Address of buffer to place the data in. */
  703.     int        bufSize;    /* Size of *bufPtr. */
  704.     int        flags;        /* Type of operatrion: OR of MSG_OOB, MSG_PEEK*/
  705. {
  706.     return(recvfrom(socketID, bufPtr, bufSize, flags, 
  707.         (struct sockaddr *) NULL, (int *) NULL));
  708. }
  709.  
  710. /*
  711.  *----------------------------------------------------------------------
  712.  *
  713.  * recvfrom --
  714.  *
  715.  *    Read data from a socket.
  716.  *
  717.  * Results:
  718.  *    If 0        - Successful.
  719.  *    If UNIX_ERROR, then errno = 
  720.  *    EINVAL        - Bad size or address for senderPtr, senderLenPtr.
  721.  *    EWOULDBLOCK    - If non-blocking, no data are available.
  722.  *    EFAULT        - Invalid argument to the ioctl.
  723.  *
  724.  * Side effects:
  725.  *    None.
  726.  *
  727.  *----------------------------------------------------------------------
  728.  */
  729.  
  730. int
  731. recvfrom(socketID, bufPtr, bufSize, flags, senderPtr, senderLenPtr)
  732.     int            socketID;    /* Socket to read. */
  733.     char        *bufPtr;    /* Buffer to place the data in. */
  734.     int            bufSize;    /* Size of *bufPtr. */
  735.     int            flags;        /* Type of operatrion: OR of 
  736.                      *  MSG_OOB, MSG_PEEK*/
  737.     struct sockaddr    *senderPtr;    /* Address of sender of the data. */
  738.     int            *senderLenPtr;    /* Size of *senderPtr. (in/out) */
  739. {
  740.     ReturnStatus    status;
  741.     int            amountRead;
  742.  
  743.     if (senderPtr != (struct sockaddr *) NULL) {
  744.     if ((senderLenPtr == (int *) NULL) ||
  745.         (*senderLenPtr != sizeof(struct sockaddr_in))) {
  746.         errno = EINVAL;
  747.         return(UNIX_ERROR);
  748.     }
  749.     }
  750.  
  751.     /*
  752.      * If there are flags, ship them to the server.
  753.      */
  754.     if (flags != 0) {
  755.     status = Fs_IOControl(socketID, IOC_NET_RECV_FLAGS,
  756.                 sizeof(flags), (Address) &flags, 
  757.                 0, (Address) NULL);
  758.     if (status != SUCCESS) {
  759.         DebugMsg(status, "recvfrom (ioctl recv_flags)");
  760.         errno = Compat_MapCode(status);
  761.         return(UNIX_ERROR);
  762.     }
  763.     }
  764.  
  765.     status = Fs_Read(socketID, bufSize, bufPtr, &amountRead);
  766.     if (status != SUCCESS) {
  767.     DebugMsg(status, "recvfrom (read)");
  768.     errno = Compat_MapCode(status);
  769.     return(UNIX_ERROR);
  770.     }
  771.  
  772.     /*
  773.      * If the caller wants the address of the sender, ask the server for it.
  774.      */
  775.     if (senderPtr != (struct sockaddr *) NULL) {
  776.     status = Fs_IOControl(socketID, IOC_NET_RECV_FROM,
  777.                 0, (Address) NULL,
  778.                 *senderLenPtr, (Address) senderPtr);
  779.     if (status != SUCCESS) {
  780.         DebugMsg(status, "recvfrom (ioctl get_remote)");
  781.         errno = Compat_MapCode(status);
  782.         return(UNIX_ERROR);
  783.     }
  784.     }
  785.     return(amountRead);
  786. }
  787.  
  788. /*
  789.  *----------------------------------------------------------------------
  790.  *
  791.  * recvmsg --
  792.  *
  793.  *    Read data from a socket using multiple buffers.
  794.  *
  795.  * Results:
  796.  *    If 0        - Successful.
  797.  *    If UNIX_ERROR, then errno = 
  798.  *    EINVAL        - Bad size or address for msg_name, msg_namelen;
  799.  *                I/O vector length too big.
  800.  *    EWOULDBLOCK    - If non-blocking, no data are available.
  801.  *    EFAULT        - Invalid argument to the ioctl, null address 
  802.  *               for msgPtr.
  803.  *
  804.  * Side effects:
  805.  *    None.
  806.  *
  807.  *----------------------------------------------------------------------
  808.  */
  809.  
  810. int
  811. recvmsg(socketID, msgPtr, flags)
  812.     int            socketID;    /* Sokect to read data from. */
  813.     struct msghdr    *msgPtr;    /* I/O vector of buffers to store the
  814.                      * data. */
  815.     int            flags;        /* Type of operatrion: OR of 
  816.                      *  MSG_OOB, MSG_PEEK*/
  817. {
  818.     ReturnStatus    status;
  819.     int            amountRead;
  820.  
  821.  
  822.     if (msgPtr == (struct msghdr *) NULL) {
  823.     errno = EFAULT;
  824.     return(UNIX_ERROR);
  825.     }
  826.  
  827.     if (msgPtr->msg_name != (Address) NULL) {
  828.     if (msgPtr->msg_namelen != sizeof(struct sockaddr_in)) {
  829.         errno = EINVAL;
  830.         return(UNIX_ERROR);
  831.     }
  832.     }
  833.  
  834.     if (msgPtr->msg_iovlen > MSG_MAXIOVLEN) {
  835.     errno = EINVAL;
  836.     return(UNIX_ERROR);
  837.     }
  838.  
  839.     /*
  840.      * If there are flags, ship them to the server.
  841.      */
  842.     if (flags != 0) {
  843.     status = Fs_IOControl(socketID, IOC_NET_RECV_FLAGS,
  844.                 sizeof(flags), (Address) &flags, 
  845.                 0, (Address) NULL);
  846.     if (status != SUCCESS) {
  847.         DebugMsg(status, "recvmsg (ioctl recv_flags)");
  848.         errno = Compat_MapCode(status);
  849.         return(UNIX_ERROR);
  850.     }
  851.     }
  852.  
  853.     amountRead = readv(socketID, msgPtr->msg_iov, msgPtr->msg_iovlen);
  854.     if (amountRead < 0) {
  855.     DebugMsg(errno, "recvmsg (readv)");
  856.     }
  857.     
  858.     /*
  859.      * If the caller wants the address of the sender, ask the server for it.
  860.      */
  861.     if (msgPtr->msg_name != (Address) NULL) {
  862.     status = Fs_IOControl(socketID, IOC_NET_RECV_FROM,
  863.             0, (Address) NULL,
  864.             msgPtr->msg_namelen, (Address) msgPtr->msg_name);
  865.     if (status != SUCCESS) {
  866.         DebugMsg(status, "recvmsg (ioctl recv_from)");
  867.         errno = Compat_MapCode(status);
  868.         return(UNIX_ERROR);
  869.     }
  870.     }
  871.  
  872.     return(amountRead);
  873. }
  874.  
  875. /*
  876.  *----------------------------------------------------------------------
  877.  *
  878.  * send --
  879.  *
  880.  *    Write data to a connected socket.
  881.  *
  882.  * Results:
  883.  *    See sendto().
  884.  *
  885.  * Side effects:
  886.  *    None.
  887.  *
  888.  *----------------------------------------------------------------------
  889.  */
  890.  
  891. int
  892. send(socketID, bufPtr, bufSize, flags)
  893.     int        socketID;    /* Socket to send data on. */
  894.     char    *bufPtr;    /* Address of buffer to send. */
  895.     int        bufSize;    /* Size of *bufPtr. */
  896.     int        flags;        /* Type of operatrion: OR of 
  897.                  *  MSG_OOB, MSG_PEEK, MSG_DONTROUTE. */
  898. {
  899.     return(sendto(socketID, bufPtr, bufSize, flags,(struct sockaddr *)NULL, 0));
  900. }
  901.  
  902. /*
  903.  *----------------------------------------------------------------------
  904.  *
  905.  * sendto --
  906.  *
  907.  *    Send a message from a socket.
  908.  *
  909.  * Results:
  910.  *    If 0        - Successful.
  911.  *    If UNIX_ERROR, then errno = 
  912.  *    EINVAL        - Bad size or address for destPtr, destLen..
  913.  *    EWOULDBLOCK    - If non-blocking, the server buffers are too
  914.  *              full to accept the data.
  915.  *    EMSGSIZE    - The buffer is too large to be sent in 1 packet.
  916.  *    EFAULT        - Invalid argument to the ioctl.
  917.  *
  918.  * Side effects:
  919.  *    None.
  920.  *
  921.  *----------------------------------------------------------------------
  922.  */
  923.  
  924. int
  925. sendto(socketID, bufPtr, bufSize, flags, destPtr, destLen)
  926.     int        socketID;    /* Socket to send data on. */
  927.     char    *bufPtr;    /* Address of buffer to send. */
  928.     int        bufSize;    /* Size of *bufPtr. */
  929.     int        flags;        /* Type of operatrion: OR of 
  930.                  *  MSG_OOB, MSG_PEEK, MSG_DONTROUTE. */
  931.     struct sockaddr    *destPtr;    /* Destination to send the data to. */
  932.     int            destLen;    /* Size of *destPtr.  */
  933. {
  934.     ReturnStatus    status;
  935.     int            numWritten;
  936.  
  937.     /*
  938.      * If either the flags or a destination are given, send them to the server.
  939.      */
  940.     if ((flags != 0) || (destPtr != (struct sockaddr *) NULL)) {
  941.     Net_SendInfo    sendInfo;
  942.  
  943.     if (destPtr != (struct sockaddr *) NULL) {
  944.         if (destLen != sizeof(struct sockaddr_in)) {
  945.         errno = EINVAL;
  946.         return(UNIX_ERROR);
  947.         }
  948.         sendInfo.addressValid = TRUE;
  949.         sendInfo.address.inet = *(Net_InetSocketAddr *) destPtr;
  950.     } else {
  951.         sendInfo.addressValid = FALSE;
  952.     }
  953.     sendInfo.flags = flags;
  954.  
  955.     status = Fs_IOControl(socketID, IOC_NET_SEND_INFO,
  956.             sizeof(sendInfo), (Address) &sendInfo, 
  957.             0, (Address) NULL);
  958.     if (status != SUCCESS) {
  959.         DebugMsg(status, "sendto (ioctl)");
  960.         errno = Compat_MapCode(status);
  961.         return(UNIX_ERROR);
  962.     }
  963.     }
  964.  
  965.     status = Fs_Write(socketID, bufSize, bufPtr, &numWritten);
  966.     if (status != SUCCESS) {
  967.     DebugMsg(status, "sendto (write)");
  968.     errno = Compat_MapCode(status);
  969.     return(UNIX_ERROR);
  970.     }
  971.     return(numWritten);
  972. }
  973.  
  974. /*
  975.  *----------------------------------------------------------------------
  976.  *
  977.  * sendmsg --
  978.  *
  979.  *    Send a message from a socket.
  980.  *
  981.  * Results:
  982.  *    If 0        - Successful.
  983.  *    If UNIX_ERROR, then errno = 
  984.  *    EINVAL        - Bad size or address for msg_name, msg_namelen;
  985.  *                I/O vector length too big.
  986.  *    EWOULDBLOCK    - If non-blocking, the server buffers are too full 
  987.  *              accept the data.
  988.  *    EFAULT        - Invalid argument to the ioctl, null address 
  989.  *               for msgPtr.
  990.  *
  991.  * Side effects:
  992.  *    None.
  993.  *
  994.  *----------------------------------------------------------------------
  995.  */
  996.  
  997. int
  998. sendmsg(socketID, msgPtr, flags)
  999.     int            socketID;    /* Socket to send data on. */
  1000.     struct msghdr    *msgPtr;    /* I/O vector of buffers containing
  1001.                      * data to send. */
  1002.     int            flags;        /* Type of operatrion: OR of 
  1003.                      *  MSG_OOB, MSG_PEEK, MSG_DONTROUTE. */
  1004. {
  1005.     ReturnStatus    status;
  1006.     int            numWritten;
  1007.  
  1008.     if (msgPtr == (struct msghdr *) NULL) {
  1009.     errno = EFAULT;
  1010.     return(UNIX_ERROR);
  1011.     }
  1012.  
  1013.     if (msgPtr->msg_iovlen > MSG_MAXIOVLEN) {
  1014.     errno = EINVAL;
  1015.     return(UNIX_ERROR);
  1016.     }
  1017.     
  1018.     if ((flags != 0) || (msgPtr->msg_name != (Address) NULL)) {
  1019.     Net_SendInfo    sendInfo;
  1020.  
  1021.     if (msgPtr->msg_name != (Address) NULL) {
  1022.         if (msgPtr->msg_namelen != sizeof(struct sockaddr_in)) {
  1023.         errno = EINVAL;
  1024.         return(UNIX_ERROR);
  1025.         }
  1026.         sendInfo.addressValid = TRUE;
  1027.         sendInfo.address.inet = *(Net_InetSocketAddr *)msgPtr->msg_name;
  1028.     } else {
  1029.         sendInfo.addressValid = FALSE;
  1030.     }
  1031.     sendInfo.flags = flags;
  1032.  
  1033.     status = Fs_IOControl(socketID, IOC_NET_SEND_INFO,
  1034.                 sizeof(sendInfo), (Address) &sendInfo, 
  1035.                 0, (Address) NULL);
  1036.  
  1037.     if (status != SUCCESS) {
  1038.         DebugMsg(status, "sendmsg (ioctl)");
  1039.         errno = Compat_MapCode(status);
  1040.         return(UNIX_ERROR);
  1041.     }
  1042.     }
  1043.  
  1044.     numWritten = writev(socketID, msgPtr->msg_iov, msgPtr->msg_iovlen);
  1045.     if (numWritten < 0) {
  1046.     DebugMsg(errno, "sendmsg (writev)");
  1047.     }
  1048.     return(numWritten);
  1049. }
  1050.  
  1051. /*
  1052.  *----------------------------------------------------------------------
  1053.  *
  1054.  * socket --
  1055.  *
  1056.  *    Create a socket in the Internet domain.
  1057.  *
  1058.  * Results:
  1059.  *    If > 0, the stream ID of the new socket.
  1060.  *    If UNIX_ERROR, then errno = 
  1061.  *    EINVAL        - "domain" did not specify the Internet domain.
  1062.  *    ?        - Error from Fs_Open, Fs_IOControl.
  1063.  *
  1064.  * Side effects:
  1065.  *    A new stream is created.
  1066.  *
  1067.  *----------------------------------------------------------------------
  1068.  */
  1069.  
  1070. int
  1071. socket(domain, type, protocol)
  1072.     int    domain;        /* Type of communications domain */
  1073.     int    type;        /* Type of socket: SOCK_STREAM, SOCK_DGRAM, SOCK_RAW. */
  1074.     int    protocol;    /* Specific protocol to use. */
  1075. {
  1076.     ReturnStatus    status;
  1077.     int            streamID;
  1078.  
  1079.     if (domain != PF_INET) {
  1080.     errno = EINVAL;
  1081.     return(UNIX_ERROR);
  1082.     }
  1083.  
  1084.     if (!gotHostName) {
  1085.     gotHostName = TRUE;
  1086.     if (gethostname(myHostName, sizeof(myHostName)) != 0) {
  1087.         panic("socket: Can't find my hostname\n");
  1088.     }
  1089.     sprintf(streamDevice, INET_STREAM_NAME_FORMAT, myHostName);
  1090.     sprintf(dgramDevice, INET_DGRAM_NAME_FORMAT, myHostName);
  1091.     sprintf(rawDevice, INET_RAW_NAME_FORMAT, myHostName);
  1092.     }
  1093.  
  1094.     do {
  1095.     if (type == SOCK_STREAM) {
  1096.         status = Fs_Open(streamDevice, FS_READ|FS_WRITE, 0666, &streamID);
  1097.         if (status != SUCCESS) {
  1098.         DebugMsg(status, "socket (stream)");
  1099.         errno = Compat_MapCode(status);
  1100.         if (errno != EINTR) {
  1101.             return(UNIX_ERROR);
  1102.         }
  1103.         }
  1104.     } else if (type == SOCK_DGRAM) {
  1105.         status = Fs_Open(dgramDevice, FS_READ|FS_WRITE, 0666, &streamID);
  1106.         if (status != SUCCESS) {
  1107.         DebugMsg(status, "socket (datagram)");
  1108.         errno = Compat_MapCode(status);
  1109.         if (errno != EINTR) {
  1110.             return(UNIX_ERROR);
  1111.         }
  1112.         }
  1113.     } else if (type == SOCK_RAW) {
  1114.         status = Fs_Open(rawDevice, FS_READ|FS_WRITE, 0666, &streamID);
  1115.         if (status != SUCCESS) {
  1116.         DebugMsg(status, "socket (raw)");
  1117.         errno = Compat_MapCode(status);
  1118.         if (errno != EINTR) {
  1119.             return(UNIX_ERROR);
  1120.         }
  1121.         }
  1122.     } else {
  1123.         errno = EINVAL;
  1124.         return(UNIX_ERROR);
  1125.     }
  1126.     } while (status != SUCCESS);
  1127.  
  1128.     if (protocol != 0) {
  1129.     do {
  1130.         status = Fs_IOControl(streamID, IOC_NET_SET_PROTOCOL,
  1131.                 sizeof(protocol), (Address) &protocol, 
  1132.                 0, (Address) NULL);
  1133.         if (status != SUCCESS) {
  1134.         DebugMsg(status, "socket (ioctl)");
  1135.         errno = Compat_MapCode(status);
  1136.         if (errno != EINTR) {
  1137.             return(UNIX_ERROR);
  1138.         }
  1139.         }
  1140.     } while (status != SUCCESS);
  1141.     }
  1142.  
  1143.     return(streamID);
  1144. }
  1145.  
  1146. /*
  1147.  *----------------------------------------------------------------------
  1148.  *
  1149.  * shutdown --
  1150.  *
  1151.  *    Shut down part of a full-duplex connection.
  1152.  *
  1153.  * Results:
  1154.  *    0        - The action was successful.
  1155.  *
  1156.  * Side effects:
  1157.  *    None.
  1158.  *
  1159.  *----------------------------------------------------------------------
  1160.  */
  1161.  
  1162. int
  1163. shutdown(socketID, action)
  1164.     int        socketID;    /* Socket to shut down. */
  1165.     int        action;        /* 0 -> disallow further recvs, 
  1166.                  * 1 -> disallow further sends,
  1167.                  * 2 -> combination of above. */
  1168. {
  1169.     ReturnStatus    status;
  1170.  
  1171.     status = Fs_IOControl(socketID, IOC_NET_SHUTDOWN, 
  1172.             sizeof(action), (Address) &action, 
  1173.             0, (Address) NULL);
  1174.  
  1175.     if (status != SUCCESS) {
  1176.     DebugMsg(status, "shutdown");
  1177.     errno = Compat_MapCode(status);
  1178.     return(UNIX_ERROR);
  1179.     }
  1180.     return(UNIX_SUCCESS);
  1181. }
  1182.  
  1183.  
  1184. /*
  1185.  *----------------------------------------------------------------------
  1186.  *
  1187.  * Wait --
  1188.  *
  1189.  *    Wait for the Inet server to indicate that a socket is ready
  1190.  *    for some action.
  1191.  *
  1192.  * Results:
  1193.  *    SUCCESS, or FS_TIMEOUT if a timeout occurred.
  1194.  *
  1195.  * Side effects:
  1196.  *    None.
  1197.  *
  1198.  *----------------------------------------------------------------------
  1199.  */
  1200.  
  1201. static ReturnStatus
  1202. Wait(socketID, readSelect, timeOutPtr)
  1203.     int     socketID;    /* Socket to wait on. */
  1204.     Boolean    readSelect;    /* If TRUE, select for reading, else select for
  1205.                  *  writing. */
  1206.     Time    *timeOutPtr;    /* Timeout to use for select. */
  1207. {
  1208.     ReturnStatus    status;
  1209.     int            numReady;
  1210.  
  1211.     /*
  1212.      * Wait until the Inet server indicates the socket is ready.
  1213.      */
  1214.  
  1215.     if (socketID < 32) {
  1216.     int    mask;
  1217.  
  1218.     mask = 1 << socketID;
  1219.     if (readSelect) {
  1220.         status = Fs_Select(socketID + 1, timeOutPtr, &mask, 
  1221.                     (int *) NULL, (int *) NULL, &numReady);
  1222.     } else {
  1223.         status = Fs_Select(socketID + 1, timeOutPtr, (int *) NULL, 
  1224.                     &mask, (int *) NULL, &numReady);
  1225.     }
  1226.     } else {
  1227.     int    *maskPtr;
  1228.  
  1229.     Bit_Alloc(socketID + 1, maskPtr);
  1230.     Bit_Set(socketID, maskPtr);
  1231.  
  1232.     if (readSelect) {
  1233.         status = Fs_Select(socketID + 1, timeOutPtr, maskPtr, 
  1234.                     (int *) NULL, (int *) NULL, &numReady);
  1235.     } else {
  1236.         status = Fs_Select(socketID + 1, timeOutPtr, (int *) NULL,
  1237.                     maskPtr, (int *) NULL, &numReady);
  1238.     }
  1239.     free((char *) maskPtr);
  1240.     }
  1241.  
  1242.     if (status == FS_TIMEOUT) {
  1243.     return(status);
  1244.     } else if (status != SUCCESS) {
  1245.     Stat_PrintMsg(status, "Wait (socket.c)");
  1246.     panic("Wait (socket.c): Fs_Select failed.\n");
  1247.     }
  1248.  
  1249.     if (numReady != 1) {
  1250.     panic("Wait (socket.c): Fs_Select returned %d ready\n",
  1251.                 numReady);
  1252.     }
  1253.  
  1254.     return(SUCCESS);
  1255. }
  1256. @
  1257.  
  1258.  
  1259. 1.15
  1260. log
  1261. @Another fix for Wait(), this time for the number of bits passed to the
  1262. Bit_Alloc() call.
  1263. @
  1264. text
  1265. @d13 1
  1266. a13 1
  1267. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/socket.c,v 1.14 91/09/06 18:41:01 dlong Exp Locker: dlong $ SPRITE (Berkeley)";
  1268. d996 30
  1269. a1025 12
  1270.     if (type == SOCK_STREAM) {
  1271.     status = Fs_Open(streamDevice, FS_READ|FS_WRITE, 0666, &streamID);
  1272.     if (status != SUCCESS) {
  1273.         DebugMsg(status, "socket (stream)");
  1274.         errno = Compat_MapCode(status);
  1275.         return(UNIX_ERROR);
  1276.     }
  1277.     } else if (type == SOCK_DGRAM) {
  1278.     status = Fs_Open(dgramDevice, FS_READ|FS_WRITE, 0666, &streamID);
  1279.     if (status != SUCCESS) {
  1280.         DebugMsg(status, "socket (datagram)");
  1281.         errno = Compat_MapCode(status);
  1282. d1028 1
  1283. a1028 11
  1284.     } else if (type == SOCK_RAW) {
  1285.     status = Fs_Open(rawDevice, FS_READ|FS_WRITE, 0666, &streamID);
  1286.     if (status != SUCCESS) {
  1287.         DebugMsg(status, "socket (raw)");
  1288.         errno = Compat_MapCode(status);
  1289.         return(UNIX_ERROR);
  1290.     }
  1291.     } else {
  1292.     errno = EINVAL;
  1293.     return(UNIX_ERROR);
  1294.     }
  1295. d1031 12
  1296. a1042 8
  1297.     status = Fs_IOControl(streamID, IOC_NET_SET_PROTOCOL,
  1298.                 sizeof(protocol), (Address) &protocol, 
  1299.                 0, (Address) NULL);
  1300.     if (status != SUCCESS) {
  1301.         DebugMsg(status, "socket (ioctl)");
  1302.         errno = Compat_MapCode(status);
  1303.         return(UNIX_ERROR);
  1304.     }
  1305. @
  1306.  
  1307.  
  1308. 1.14
  1309. log
  1310. @Fixed call to Wait() to pass correct bit width to Fs_Select()
  1311. @
  1312. text
  1313. @d13 1
  1314. a13 1
  1315. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/socket.c,v 1.13 91/08/12 17:06:47 mottsmth Exp Locker: dlong $ SPRITE (Berkeley)";
  1316. d1119 1
  1317. a1119 1
  1318.     Bit_Alloc(socketID, maskPtr);
  1319. @
  1320.  
  1321.  
  1322. 1.13
  1323. log
  1324. @Modify accept routine to tolerate an addrLen
  1325. greater than sizeof struct sockaddr_in.
  1326. @
  1327. text
  1328. @d13 1
  1329. a13 1
  1330. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/socket.c,v 1.12 91/07/17 16:04:46 mendel Exp Locker: mottsmth $ SPRITE (Berkeley)";
  1331. d1110 1
  1332. a1110 1
  1333.         status = Fs_Select(socketID, timeOutPtr, &mask, 
  1334. d1113 1
  1335. a1113 1
  1336.         status = Fs_Select(socketID, timeOutPtr, (int *) NULL, 
  1337. d1123 1
  1338. a1123 1
  1339.         status = Fs_Select(socketID, timeOutPtr, maskPtr, 
  1340. d1126 1
  1341. a1126 1
  1342.         status = Fs_Select(socketID, timeOutPtr, (int *) NULL,
  1343. @
  1344.  
  1345.  
  1346. 1.12
  1347. log
  1348. @Modified call to Wait() not to pass "const" which was getting changed 
  1349. by Fs_Select().
  1350. @
  1351. text
  1352. @d13 1
  1353. a13 1
  1354. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/socket.c,v 1.11 89/09/12 11:43:48 nelson Exp Locker: mendel $ SPRITE (Berkeley)";
  1355. d94 1
  1356. a94 1
  1357.     if (addrLen != sizeof(struct sockaddr_in)) {
  1358. @
  1359.  
  1360.  
  1361. 1.11
  1362. log
  1363. @changes for the ultrix compatibility port (ci by FD)
  1364. @
  1365. text
  1366. @d13 1
  1367. a13 1
  1368. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/socket.c,v 1.10 88/10/24 09:15:51 douglis Exp Locker: nelson $ SPRITE (Berkeley)";
  1369. d267 1
  1370. d300 2
  1371. a301 1
  1372.     status = Wait(socketID, FALSE, &time_OneMinute);
  1373. @
  1374.  
  1375.  
  1376. 1.10
  1377. log
  1378. @Do select with timeouts and convert FS_TIMEOUT to ETIMEDOUT on connects.
  1379. @
  1380. text
  1381. @d13 1
  1382. a13 1
  1383. static char rcsid[] = "$Header: socket.c,v 1.9 88/07/29 17:39:36 ouster Exp $ SPRITE (Berkeley)";
  1384. d359 4
  1385. d364 1
  1386. a364 1
  1387.     *nameLenPtr != sizeof(struct sockaddr_in)) {
  1388. d368 1
  1389. @
  1390.  
  1391.  
  1392. 1.9
  1393. log
  1394. @Lint.
  1395. @
  1396. text
  1397. @d13 1
  1398. a13 1
  1399. static char rcsid[] = "$Header: socket.c,v 1.8 88/07/25 14:53:31 ouster Exp $ SPRITE (Berkeley)";
  1400. d33 1
  1401. a33 1
  1402. static void Wait();
  1403. d128 1
  1404. a128 1
  1405.         Wait(socketID, TRUE);
  1406. d299 1
  1407. a299 1
  1408.     Wait(socketID, FALSE);
  1409. d301 6
  1410. d1076 1
  1411. a1076 1
  1412.  *    None.
  1413. d1084 2
  1414. a1085 2
  1415. static void
  1416. Wait(socketID, readSelect)
  1417. d1089 1
  1418. d1103 1
  1419. a1103 1
  1420.         status = Fs_Select(socketID, (Time *)NULL, &mask, 
  1421. d1106 1
  1422. a1106 1
  1423.         status = Fs_Select(socketID, (Time *)NULL, (int *) NULL, 
  1424. d1116 1
  1425. a1116 1
  1426.         status = Fs_Select(socketID, (Time *)NULL, maskPtr, 
  1427. d1119 1
  1428. a1119 1
  1429.         status = Fs_Select(socketID, (Time *)NULL, (int *) NULL,
  1430. d1125 3
  1431. a1127 1
  1432.     if (status != SUCCESS) {
  1433. d1136 2
  1434. @
  1435.  
  1436.  
  1437. 1.8
  1438. log
  1439. @Somehow I lost the last round of changes.  This redoes.
  1440. @
  1441. text
  1442. @d13 1
  1443. a13 1
  1444. static char rcsid[] = "$Header: socket.c,v 1.7 88/07/25 14:23:42 ouster Exp $ SPRITE (Berkeley)";
  1445. d305 2
  1446. a306 1
  1447.     if (getsockopt(socketID, SOL_SOCKET, SO_ERROR, &status, &statLen) < 0) {
  1448. d513 1
  1449. a513 1
  1450.     newBufPtr = (int *) malloc(2 * sizeof(int) + optLen);
  1451. @
  1452.  
  1453.  
  1454. 1.7
  1455. log
  1456. @Lint.
  1457. @
  1458. text
  1459. @d13 1
  1460. a13 1
  1461. static char rcsid[] = "$Header: socket.c,v 1.6 88/07/25 11:25:10 ouster Exp $ SPRITE (Berkeley)";
  1462. d319 1
  1463. a707 1
  1464.     int            i;
  1465. a894 1
  1466.     int            i;
  1467. @
  1468.  
  1469.  
  1470. 1.6
  1471. log
  1472. @Lint.
  1473. @
  1474. text
  1475. @d13 1
  1476. a13 1
  1477. static char rcsid[] = "$Header: socket.c,v 1.5 88/07/25 10:39:54 ouster Exp $ SPRITE (Berkeley)";
  1478. @
  1479.  
  1480.  
  1481. 1.5
  1482. log
  1483. @Conversion back to UNIX library procedures.
  1484. @
  1485. text
  1486. @d13 1
  1487. a13 1
  1488. static char rcsid[] = "$Header: socket.c,v 1.4 88/06/21 17:25:03 ouster Exp $ SPRITE (Berkeley)";
  1489. d16 6
  1490. d23 2
  1491. a30 7
  1492. #include <sprite.h>
  1493. #include <inet.h>
  1494. #include <dev/net.h>
  1495. #include <sys.h>
  1496. #include <fs.h>
  1497. #include <bit.h>
  1498. #include <status.h>
  1499. a31 6
  1500.  
  1501. /*
  1502.  * Library imports:
  1503.  */
  1504.  
  1505. char *malloc();
  1506. @
  1507.  
  1508.  
  1509. 1.4
  1510. log
  1511. @Various changes to make code compile under new library.
  1512. @
  1513. text
  1514. @d13 1
  1515. a13 1
  1516. static char rcsid[] = "$Header: socket.c,v 1.3 88/06/21 11:47:43 ouster Exp $ SPRITE (Berkeley)";
  1517. a296 1
  1518.         Proc_Exit(FAILURE);
  1519. a711 1
  1520.     Fs_IOVector        *vectorPtr;
  1521. a744 13
  1522.     
  1523.     /*
  1524.      * The Sprite and Unix I/O vectors have different formats so
  1525.      * we have to translate msgPtr->msg_iov to the Sprite format.
  1526.      */
  1527.     vectorPtr = (Fs_IOVector *) malloc(msgPtr->msg_iovlen * 
  1528.                         sizeof(Fs_IOVector));
  1529.     for (i = 0; i < msgPtr->msg_iovlen; i++) {
  1530.     vectorPtr[i].bufSize = msgPtr->msg_iov[i].iov_len;
  1531.     vectorPtr[i].buffer  = msgPtr->msg_iov[i].iov_base;
  1532.     }
  1533.     status = Fs_ReadVector(socketID, msgPtr->msg_iovlen, vectorPtr,
  1534.                 &amountRead);
  1535. d746 3
  1536. a748 6
  1537.     free((char *) vectorPtr);
  1538.  
  1539.     if (status != SUCCESS) {
  1540.     DebugMsg(status, "recvmsg (readv)");
  1541.     errno = Compat_MapCode(status);
  1542.     return(UNIX_ERROR);
  1543. a899 1
  1544.     Fs_IOVector        *vectorPtr;
  1545. d938 3
  1546. a940 9
  1547.     /*
  1548.      * The Sprite and Unix I/O vectors have different formats so
  1549.      * we have to translate msgPtr->msg_iov to the Sprite format.
  1550.      */
  1551.     vectorPtr = (Fs_IOVector *) malloc(msgPtr->msg_iovlen * 
  1552.                         sizeof(Fs_IOVector));
  1553.     for (i = 0; i < msgPtr->msg_iovlen; i++) {
  1554.     vectorPtr[i].bufSize = msgPtr->msg_iov[i].iov_len;
  1555.     vectorPtr[i].buffer  = msgPtr->msg_iov[i].iov_base;
  1556. a941 9
  1557.     status = Fs_WriteVector(socketID, msgPtr->msg_iovlen, vectorPtr,
  1558.                     &numWritten);
  1559.     free((char *) vectorPtr);
  1560.  
  1561.     if (status != SUCCESS) {
  1562.     DebugMsg(status, "sendmsg (writev)");
  1563.     errno = Compat_MapCode(status);
  1564.     return(UNIX_ERROR);
  1565.     }
  1566. d980 1
  1567. a980 1
  1568.     if (Sys_GetHostName(sizeof(myHostName), myHostName) != SUCCESS) {
  1569. d983 3
  1570. a985 3
  1571.     Io_PrintString(streamDevice, INET_STREAM_NAME_FORMAT, myHostName);
  1572.     Io_PrintString(dgramDevice, INET_DGRAM_NAME_FORMAT, myHostName);
  1573.     Io_PrintString(rawDevice, INET_RAW_NAME_FORMAT, myHostName);
  1574. a1125 1
  1575.     Proc_Exit(FAILURE);
  1576. a1130 1
  1577.     Proc_Exit(FAILURE);
  1578. @
  1579.  
  1580.  
  1581. 1.3
  1582. log
  1583. @Must include status.h.
  1584. @
  1585. text
  1586. @d13 1
  1587. a13 1
  1588. static char rcsid[] = "$Header: socket.c,v 1.2 88/06/21 11:22:46 ouster Exp $ SPRITE (Berkeley)";
  1589. a23 1
  1590. #include <net.h>
  1591. @
  1592.  
  1593.  
  1594. 1.2
  1595. log
  1596. @Use panic instead of Sys_Panic.
  1597. @
  1598. text
  1599. @d13 1
  1600. a13 1
  1601. static char rcsid[] = "$Header: socket.c,v 1.1 88/06/19 14:32:03 ouster Exp $ SPRITE (Berkeley)";
  1602. d23 8
  1603. a30 7
  1604. #include "sprite.h"
  1605. #include "net.h"
  1606. #include "inet.h"
  1607. #include "dev/net.h"
  1608. #include "sys.h"
  1609. #include "fs.h"
  1610. #include "bit.h"
  1611. @
  1612.  
  1613.  
  1614. 1.1
  1615. log
  1616. @Initial revision
  1617. @
  1618. text
  1619. @d13 1
  1620. a13 1
  1621. static char rcsid[] = "$Header: socket.c,v 1.6 87/08/10 12:05:32 andrew Exp $ SPRITE (Berkeley)";
  1622. d16 1
  1623. d296 1
  1624. a296 1
  1625.         Sys_Panic(SYS_FATAL, "connect: GET_FLAGS failed.\n");
  1626. d1015 1
  1627. a1015 1
  1628.         Sys_Panic(SYS_FATAL, "socket: Can't find my hostname\n");
  1629. d1159 1
  1630. a1159 1
  1631.     Sys_Panic(SYS_FATAL, "Wait (socket.c): Fs_Select failed.\n");
  1632. d1164 1
  1633. a1164 1
  1634.     Sys_Panic(SYS_FATAL, "Wait (socket.c): Fs_Select returned %d ready\n",
  1635. @
  1636.